Page({
    data: {
        // 人员数据
        allPersons: [], // 所有人员数据
        filteredPersons: [], // 筛选后的人员数据

        // 标签筛选
        allTags: [], // 所有可用标签
        selectedTags: [], // 选中的标签
        showTagFilter: false, // 是否显示标签筛选器

        // 搜索
        searchKeyword: '', // 搜索关键词

        // 弹窗控制
        showDeleteModal: false,
        deletePersonId: null,
        deletePersonName: '',

        // 详情弹窗控制
        showDetailModal: false,
        detailPersonName: '',
        detailPersonTags: '',
        detailPersonProject: '',

        // 标签编辑弹窗控制
        showTagsModal: false,
        selectedPerson: { name: '', tags: [] },
        newTag: '',

        // 模态框配置
        deleteModalActions: [
            { name: '取消', color: '#999' },
            { name: '删除', color: '#ed3f14' }
        ],
        detailModalActions: [
            { name: '关闭', color: '#2d8cf0' }
        ],
        tagsModalActions: [
            { name: '关闭', color: '#2d8cf0' }
        ]
    },

    onLoad() {
        this.loadPersonsFromServer();
    },

    onShow() {
        // 每次显示页面时重新加载数据
        this.loadPersonsFromServer();
    },

    /**
     * 从服务器加载人员数据
     */
    loadPersonsFromServer() {
        const app = getApp();
        wx.request({
            url: app.globalData.api + '/ProjectManager/GetAllPersons',
            data: {
                token: app.globalData.userInfo.token
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) {
                    const persons = res.data.data || [];
                    this.setData({
                        allPersons: persons,
                        filteredPersons: persons
                    });
                    this.extractAllTags(persons);
                } else {
                    wx.showToast({
                        title: res.data.message || '加载数据失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('加载人员数据失败:', err);
                wx.showToast({
                    title: '网络请求失败',
                    icon: 'none'
                });
            }
        });
    },

    /**
     * 提取所有标签
     */
    extractAllTags(persons) {
        const tagMap = new Map();

        persons.forEach(person => {
            if (person.tags && Array.isArray(person.tags)) {
                person.tags.forEach(tag => {
                    if (tag && tag.name) {
                        // 按标签名称去重，保存所有具有该名称的标签ID
                        if (!tagMap.has(tag.name)) {
                            tagMap.set(tag.name, {
                                name: tag.name,
                                ids: [tag.id],
                                displayId: tag.id, // 用于显示的主要ID
                                selected: false // 添加选中状态
                            });
                        } else {
                            const existingTag = tagMap.get(tag.name);
                            if (!existingTag.ids.includes(tag.id)) {
                                existingTag.ids.push(tag.id);
                            }
                        }
                    }
                });
            }
        });

        const allTags = Array.from(tagMap.values());
        console.log('提取到的所有标签:', allTags);
        this.setData({
            allTags: allTags
        });
    },

    /**
     * 搜索输入处理
     */
    onSearchInput(e) {
        const keyword = e.detail.detail.value;
        this.setData({
            searchKeyword: keyword
        });
        this.filterPersons();
    },

    /**
     * 显示/隐藏标签筛选器
     */
    toggleTagFilter() {
        this.setData({
            showTagFilter: !this.data.showTagFilter
        });
    },

    /**
     * 标签选择处理
     */
    onTagSelect(e) {
        const tagName = e.currentTarget.dataset.tagName;
        console.log('点击标签:', tagName);

        let selectedTags = [...this.data.selectedTags];
        let allTags = [...this.data.allTags];

        console.log('点击前 selectedTags:', selectedTags);

        const index = selectedTags.indexOf(tagName);
        console.log('indexOf 结果:', index);

        if (index > -1) {
            // 移除标签
            selectedTags.splice(index, 1);
            console.log('移除后 selectedTags:', selectedTags);
        } else {
            // 添加标签
            selectedTags.push(tagName);
            console.log('添加后 selectedTags:', selectedTags);
        }

        // 更新allTags中的选中状态
        allTags = allTags.map(tag => ({
            ...tag,
            selected: selectedTags.includes(tag.name)
        }));

        console.log('更新后的 allTags:', allTags);

        this.setData({
            selectedTags: selectedTags,
            allTags: allTags
        }, () => {
            console.log('设置完成后的 selectedTags:', this.data.selectedTags);
            console.log('设置完成后的 allTags:', this.data.allTags);
            this.filterPersons();
        });
    },

    /**
     * 清除所有筛选
     */
    clearAllFilters() {
        // 重置所有标签的选中状态
        const allTags = this.data.allTags.map(tag => ({
            ...tag,
            selected: false
        }));

        this.setData({
            selectedTags: [],
            searchKeyword: '',
            filteredPersons: this.data.allPersons,
            allTags: allTags
        });
    },

    /**
     * 筛选人员
     */
    filterPersons() {
        const { allPersons, selectedTags, searchKeyword } = this.data;
        let filtered = [...allPersons];

        // 按关键词搜索
        if (searchKeyword.trim()) {
            const keyword = searchKeyword.trim().toLowerCase();
            filtered = filtered.filter(person =>
                person.name.toLowerCase().includes(keyword) ||
                (person.projectName && person.projectName.toLowerCase().includes(keyword))
            );
        }

        // 按标签筛选
        if (selectedTags.length > 0) {
            filtered = filtered.filter(person => {
                if (!person.tags || !Array.isArray(person.tags)) {
                    return false;
                }

                // 检查人员是否包含所有选中的标签（与的关系）
                return selectedTags.every(selectedTag =>
                    person.tags.some(tag => tag.name === selectedTag)
                );
            });
        }

        this.setData({
            filteredPersons: filtered
        });
    },

    /**
     * 查看人员详情
     */
    viewPersonDetail(e) {
        const personId = parseInt(e.currentTarget.dataset.personId);
        const person = this.data.allPersons.find(p => p.id === personId);

        if (person) {
            console.log('查看人员详情:', person); // 添加调试信息

            // 格式化标签信息
            const tagsText = person.tags && person.tags.length > 0
                ? person.tags.map(tag => tag.name).join('、')
                : '无';

            // 格式化项目信息
            const projectText = person.projectName || '未分配';

            // 使用自定义弹窗显示详情
            this.setData({
                showDetailModal: true,
                detailPersonName: person.name,
                detailPersonTags: tagsText,
                detailPersonProject: projectText
            });
        } else {
            console.log('未找到人员信息, personId:', personId);
            wx.showToast({
                title: '人员信息不存在',
                icon: 'none'
            });
        }
    },

    /**
     * 删除人员
     */
    deletePerson(e) {
        const personId = parseInt(e.currentTarget.dataset.personId);
        const person = this.data.allPersons.find(p => p.id === personId);

        if (!person) {
            wx.showToast({
                title: '人员信息不存在',
                icon: 'none'
            });
            return;
        }

        this.setData({
            showDeleteModal: true,
            deletePersonId: personId,
            deletePersonName: person.name
        });
    },

    /**
     * 删除确认弹窗处理
     */
    handleDeleteModalClick(e) {
        const index = e.detail.index;
        if (index === 1) {
            // 点击删除
            this.confirmDeletePerson();
        } else {
            // 点击取消
            this.cancelDeletePerson();
        }
    },

    /**
     * 确认删除人员
     */
    confirmDeletePerson() {
        const { deletePersonId, deletePersonName } = this.data;

        const app = getApp();
        wx.request({
            url: app.globalData.api + '/ProjectManager/DeletePerson',
            data: {
                token: app.globalData.userInfo.token,
                personId: deletePersonId
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) {
                    wx.showToast({
                        title: `${deletePersonName}已删除`,
                        icon: 'success'
                    });

                    // 重新加载数据
                    this.loadPersonsFromServer();
                } else {
                    wx.showToast({
                        title: res.data.message || '删除失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('删除人员失败:', err);
                wx.showToast({
                    title: '网络请求失败',
                    icon: 'none'
                });
            },
            complete: () => {
                this.setData({
                    showDeleteModal: false,
                    deletePersonId: null,
                    deletePersonName: ''
                });
            }
        });
    },

    /**
     * 取消删除
     */
    cancelDeletePerson() {
        this.setData({
            showDeleteModal: false,
            deletePersonId: null,
            deletePersonName: ''
        });
    },

    /**
     * 详情弹窗处理
     */
    handleDetailModalClick(e) {
        this.setData({
            showDetailModal: false,
            detailPersonName: '',
            detailPersonTags: '',
            detailPersonProject: ''
        });
    },

    /**
     * 编辑人员标签
     */
    editPersonTags(e) {
        const personId = parseInt(e.currentTarget.dataset.personId);
        const person = this.data.allPersons.find(p => p.id === personId);

        if (person) {
            console.log('编辑人员标签:', person);
            this.setData({
                selectedPerson: { ...person },
                showTagsModal: true,
                newTag: ''
            });
        } else {
            wx.showToast({
                title: '人员信息不存在',
                icon: 'none'
            });
        }
    },

    /**
     * 关闭标签弹窗
     */
    closeTagsModal() {
        this.setData({
            showTagsModal: false
        });
    },

    /**
     * 标签模态框点击事件
     */
    handleTagsModalClick(e) {
        // 点击关闭按钮
        this.closeTagsModal();
    },

    /**
     * 新标签输入
     */
    onNewTagChange(e) {
        this.setData({
            newTag: e.detail.detail.value
        });
    },

    /**
     * 添加标签
     */
    addTag() {
        const { newTag, selectedPerson } = this.data;
        const trimmedTag = newTag.trim();

        if (!trimmedTag) {
            wx.showToast({
                title: '请输入标签名称',
                icon: 'none'
            });
            return;
        }

        // 检查是否已存在相同标签
        if (selectedPerson.tags.some(tag => tag.name === trimmedTag)) {
            wx.showToast({
                title: '标签已存在',
                icon: 'none'
            });
            return;
        }

        const app = getApp();
        wx.request({
            url: app.globalData.api + '/ProjectManager/AddPersonTag',
            data: {
                token: app.globalData.userInfo.token,
                personId: selectedPerson.id,
                tagName: trimmedTag
            },
            method: 'GET',
            success: (res) => {
                if (res.data.resultCode === 0) {
                    wx.showToast({
                        title: '添加成功',
                        icon: 'success'
                    });

                    // 添加新标签到当前人员
                    const newTagObj = { id: res.data.data.id, name: res.data.data.tagName };
                    const updatedPerson = {
                        ...selectedPerson,
                        tags: [...selectedPerson.tags, newTagObj]
                    };

                    this.setData({
                        selectedPerson: updatedPerson,
                        newTag: ''
                    });

                    // 重新加载数据
                    this.loadPersonsFromServer();
                } else {
                    wx.showToast({
                        title: res.data.message || '添加失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('添加标签失败:', err);
                wx.showToast({
                    title: '网络请求失败',
                    icon: 'none'
                });
            }
        });
    },

    /**
     * 删除标签
     */
    deleteTag(e) {
        const index = parseInt(e.currentTarget.dataset.index);
        const { selectedPerson } = this.data;
        const tagToDelete = selectedPerson.tags[index];

        if (!tagToDelete) {
            wx.showToast({
                title: '标签不存在',
                icon: 'none'
            });
            return;
        }

        wx.showModal({
            title: '删除标签',
            content: `确定要删除标签“${tagToDelete.name}”吗？`,
            success: (res) => {
                if (res.confirm) {
                    const app = getApp();
                    wx.request({
                        url: app.globalData.api + '/ProjectManager/DeletePersonTag',
                        data: {
                            token: app.globalData.userInfo.token,
                            tagId: tagToDelete.id
                        },
                        method: 'GET',
                        success: (apiRes) => {
                            if (apiRes.data.resultCode === 0) {
                                wx.showToast({
                                    title: '删除成功',
                                    icon: 'success'
                                });

                                // 从当前人员中移除标签
                                const updatedTags = selectedPerson.tags.filter((_, i) => i !== index);
                                const updatedPerson = {
                                    ...selectedPerson,
                                    tags: updatedTags
                                };

                                this.setData({
                                    selectedPerson: updatedPerson
                                });

                                // 重新加载数据
                                this.loadPersonsFromServer();
                            } else {
                                wx.showToast({
                                    title: apiRes.data.message || '删除失败',
                                    icon: 'none'
                                });
                            }
                        },
                        fail: (err) => {
                            console.error('删除标签失败:', err);
                            wx.showToast({
                                title: '网络请求失败',
                                icon: 'none'
                            });
                        }
                    });
                }
            }
        });
    },

    /**
     * 跳转到项目管理
     */
    goToZoneManager() {
        wx.navigateTo({
            url: '/pages/zone-manager/index'
        });
    },

    onShareAppMessage() {
        return {
            title: '记录你的一点一滴~',
            desc: '记录你的一点一滴~',
            path: 'pages/index/index',
            imageUrl: getApp().globalData.shareImgUrl
        }
    }
})